Como faço para desfazer os commits locais mais recentes no Git?

1
2
3
Próximo
Desfazer um commit e refazer
$ git commit -m "Algo terrivelmente errado" # (0: Seu acidente)
$ git reset HEAD ~ # (1)
<< edite os arquivos conforme necessário >> # (2)
$ git add. # (3)
$ git commit -c ORIG_HEAD # (4)
Este comando é responsável pelo desfazer. Isso irá desfazer seu último commit enquanto deixa sua árvore de trabalho (o estado de seus arquivos no disco) intocada. Você precisará adicioná-los novamente antes de confirmá-los novamente).
Faça correções nos arquivos da árvore de trabalho.
git adicione qualquer coisa que você deseja incluir em seu novo commit.
Confirme as alterações, reutilizando a mensagem de confirmação antiga. redefinir copiou o antigo cabeçalho para .git / ORIG_HEAD; commit com -c ORIG_HEAD irá abrir um editor, que inicialmente contém a mensagem de log do commit antigo e permite que você o edite. Se você não precisa editar a mensagem, pode usar a opção -C.
Alternativamente, para editar o commit anterior (ou apenas sua mensagem), commit --amend irá adicionar mudanças dentro do índice atual ao commit anterior.
Para remover (não reverter) um commit que foi enviado para o servidor, é necessário reescrever o histórico com git push origin master --force.
Leitura Adicional
Como posso mover o HEAD de volta para um local anterior? (Cabeça destacada) e Desfazer confirmações
A resposta acima mostrará git reflog, que você pode usar para determinar o SHA-1 para o commit para o qual deseja reverter. Assim que tiver esse valor, use a sequência de comandos conforme explicado acima.
HEAD ~ é igual a HEAD ~ 1. O artigo Qual é o HEAD no git? é útil se você deseja descomprimir vários commits.
|
Desfazer um commit é um pouco assustador se você não sabe como funciona. Mas é realmente incrivelmente fácil se você entender. Vou mostrar as 4 maneiras diferentes de desfazer um commit.
opção 1: git reset --hard
Digamos que você tenha isso, onde C é seu HEAD e (F) é o estado de seus arquivos.
(F)
ABC
↑
mestre
Você deseja destruir o commit C e nunca mais vê-lo e perder todas as alterações nos arquivos modificados localmente. Você faz isso:
git reset --hard HEAD ~ 1
O resultado é:
(F)
A-B
↑
mestre
Agora B é a CABEÇA. Como você usou --hard, seus arquivos são redefinidos para seu estado no commit B.
opção 2: git reset
Ah, mas suponha que cometer C não seja um desastre, mas apenas um pouco errado. Você quer desfazer o commit, mas manter suas mudanças para um pouco de edição antes de fazer um commit melhor. Começando novamente a partir daqui, com C como CABEÇA:
(F)
ABC
↑
mestre
Você pode fazer isso, deixando de fora o --hard:
git reset HEAD ~ 1
Neste caso, o resultado é:
(F)
ABC
↑
mestre
Em ambos os casos, HEAD é apenas um ponteiro para o último commit. Quando você faz um git reset HEAD ~ 1, diz ao Git para mover o ponteiro HEAD para trás um commit. Mas (a menos que você use --hard) você deixa seus arquivos como estavam. Então agora git status mostra as mudanças que você verificou em C. Você não perdeu nada!
opção 3: git reset --soft
Por um toque mais leve, você pode até desfazer seu commit, mas deixar seus arquivos e seu índice:
git reset --soft HEAD ~ 1
Isso não apenas deixa seus arquivos em paz, mas também deixa seu índice sozinho. Quando você faz git status, você verá que os mesmos arquivos estão no índice como antes. Na verdade, logo após este comando, você poderia fazer git commit e refazer o mesmo commit que acabou de fazer.
opção 4: você fez git reset --hard e precisa obter esse código de volta
Mais uma coisa: suponha que você destrua um commit como no primeiro exemplo, mas então descubra que precisa dele afinal? Que azar, certo?
Não, ainda há uma maneira de recuperá-lo. Digite git reflog e você verá uma lista de commits (parciais) (ou seja, hashes) que você moveu. Encontre o commit que você destruiu e faça o seguinte:
git checkout -b someNewBranchName shaYouDestroyed
Você agora ressuscitou aquele commit. Os commits não são destruídos no Git por cerca de 90 dias, então você normalmente pode voltar e resgatar um do qual você não pretendia se livrar.
|
Existem duas maneiras de "desfazer" seu último commit, dependendo se você já tornou seu commit público (enviado para seu repositório remoto) ou não:
Como desfazer um commit local
Digamos que eu tenha cometido localmente, mas agora quero remover esse commit.
git log
commit 101: mau commit # Último commit. Isso seria chamado de 'HEAD'.
commit 100: bom commit # Segundo até o último commit. Este é o que queremos.
Para restaurar tudo de volta para a forma como estava antes do último commit, precisamos redefinir para o commit antes de HEAD:
git reset --soft HEAD ^ # Use --soft se quiser manter suas alterações
git reset --hard HEAD ^ # Use --hard se você não se importa em manter as alterações feitas
Agora o git log mostrará que nosso último commit foi removido.
Como desfazer um commit público
Se você já tornou seus commits públicos, você vai querer criar um novo commit que irá "reverter" as mudanças que você fez em seu commit anterior (HEAD atual).
git revert HEAD
Suas alterações agora serão revertidase pronto para você se comprometer:
git commit -m 'restaurando o arquivo que removi acidentalmente'
git log
commit 102: restaurando o arquivo que removi por acidente
commit 101: removendo um arquivo que não precisamos
commit 100: adicionando um arquivo que precisamos
Para obter mais informações, consulte Git Basics - Undoing Things.
|
Adicione / remova arquivos para fazer as coisas como você deseja:
git rm classdir
git add sourcedir
Em seguida, altere o commit:
git commit --amend
O commit anterior errôneo será editado para refletir o novo estado do índice - em outras palavras, será como se você nunca tivesse cometido o erro.
Observe que você só deve fazer isso se ainda não tiver feito push. Se você tiver feito push, então terá que fazer uma correção normalmente.
|
git rm yourfiles / *. class
git commit -a -m "excluiu todos os arquivos de classe na pasta 'seusarquivos'"
ou
git reset --hard HEAD ~ 1
Aviso: O comando acima removerá permanentemente as modificações nos arquivos .java (e quaisquer outros arquivos) que você deseja enviar.
O hard reset para HEAD-1 irá definir sua cópia de trabalho para o estado do commit antes do seu commit errado.
|
Para alterar o último commit
Substitua os arquivos no índice:
git rm --cached * .class
git add * .java
Então, se for um branch privado, altere o commit:
git commit --amend
Ou, se for um branch compartilhado, faça um novo commit:
git commit -m 'Substituir arquivos .class por arquivos .java'
(Para alterar um commit anterior, use o incrível rebase interativo.)
ProTip ™: Adicione * .class a um gitignore para impedir que isso aconteça novamente.
Para reverter um commit
Corrigir um commit é a solução ideal se você precisar alterar o último commit, mas uma solução mais geral é redefinida.
Você pode redefinir o Git para qualquer commit com:
git reset @ ~ N
Onde N é o número de commits antes de HEAD, e @ ~ reseta para o commit anterior.
Então, em vez de alterar o commit, você pode usar:
git reset @ ~
git add * .java
git commit -m "Adicionar arquivos .java"
Verifique git help reset, especificamente as seções sobre --soft --mixed e --hard, para uma melhor compreensão do que isso faz.
Reflog
Se você errar, você sempre pode usar o reflog para encontrar commits descartados:
$ git reset @ ~
$ git reflog
c4f708b HEAD @ {0}: redefinir: mover para @ ~
2c52489 HEAD @ {1}: commit: adicionado alguns arquivos .class
$ git reset 2c52489
... e você está de volta onde você começou
|
Use git revert .
Para obter o ID de confirmação, basta usar o git log.
|
Se você está planejando desfazer um commit local inteiramente, seja o que for que você mudou no commit, e se você não se preocupa com isso, apenas execute o seguinte comando.
git reset --hard HEAD ^ 1
(Este comando irá ignorar todo o seu commit e suas mudanças serão perdidas completamente da sua árvore de trabalho local). Se você quiser desfazer o seu commit, mas quiser suas mudanças na área de teste (antes do commit, assim como depois do git add), faça o seguinte comando.
git reset --soft HEAD ^ 1
Agora seus arquivos confirmados entram na área de teste. Suponha que se você deseja ultrapassar os arquivos, porque precisa editar algum conteúdo errado, execute o seguinte comando
git reset HEAD
Agora, os arquivos confirmados para vir da área encenada para a área não encenada. Agora os arquivos estão prontos para serem editados, então o que quer que você mude, você deseja editar e adicionar e fazer um novo / novo commit.
Mais (link quebrado) (versão arquivada)
|
Se você tem Git Extras instalado, você pode executar git undo para desfazer o último commit. git undo 3 desfará os últimos três commits.
|
Eu queria desfazer os últimos cinco commits em nosso repositório compartilhado. Eu pesquisei o id de revisão para o qual eu queria reverter. Então eu digitei o seguinte.
prompt> git reset --hard 5a7404742c85
HEAD está agora em 5a74047 Adicionada mais uma página ao catálogo
prompt> git push origin master --force
Total 0 (delta 0), reutilizado 0 (delta 0)
remoto: bb / acl: neoneye é permitido. carga útil aceita.
Para git@bitbucket.org: thecompany / prometheus.git
+ 09a6480 ... 5a74047 mestre -> mestre (atualização forçada)
prompt>
|
Eu prefiro usar git rebase -i para este trabalho, porque uma boa lista aparece onde posso escolher os commits dos quais me livrar. Pode não ser tão direto como algumas outras respostas aqui, mas parece certo.
Escolha quantos commits você deseja listar, então invoque assim (para listar os três últimos)
git rebase -i HEAD ~ 3
Lista de amostra
escolha aa28ba7 verificação de integridade para porta RtmpSrv
escolha a opção de versão c26c541 RtmpSrv
pick 58d6909 Melhor suporte de decodificação de URL
Então o Git removerá os commits de qualquer linha que você remover.
|
Como corrigir o commit local anterior
Use git-gui (ou similar) para executar um git commit --amend. A partir da GUI, você pode adicionar ou remover arquivos individuais do commit. Você também pode modificar a mensagem de confirmação.
Como desfazer o commit local anterior
Basta redefinir seu branch para o local anterior (por exemplo, usando gitk ou git rebase). Em seguida, reaplique suas alterações de uma cópia salva. Após a coleta de lixo em seu repositório local, será como se o commit indesejado nunca tivesse acontecido. Para fazer tudo isso em um único comando, use git reset HEAD ~ 1.
Palavraaviso: o uso descuidado de git reset é uma boa maneira de deixar sua cópia de trabalho em um estado confuso. Eu recomendo que os novatos em Git evitem isso, se puderem.
Como desfazer um commit público
Execute uma seleção cereja reversa (git-revert) para desfazer as alterações.
Se você ainda não fez outras alterações em seu branch, você pode simplesmente fazer ...
git revert --no-edit HEAD
Em seguida, envie seu branch atualizado para o repositório compartilhado.
O histórico de commits mostrará ambos os commits, separadamente.
Avançado: Correção de agência privada em repositório público
Isso pode ser perigoso - certifique-se de ter uma cópia local do branch para repush.
Observe também: você não deseja fazer isso se outra pessoa estiver trabalhando no branch.
git push --delete (branch_name) ## remove a versão pública do branch
Limpe o seu ramo localmente e depois repush ...
git push origin (branch_name)
No caso normal, você provavelmente não precisa se preocupar com o histórico de commits de seu branch privado intocado. Basta enviar um commit de acompanhamento (consulte 'Como desfazer um commit público' acima) e, mais tarde, faça um squash-merge para ocultar o histórico.
|
Se você deseja desfazê-lo permanentemente e você clonou algum repositório
O ID do commit pode ser visto por
git log
Então você pode fazer -
git reset --hard 
git push origin  -f
|
Se você cometeu lixo, mas não empurrou,
git reset --soft HEAD ~ 1
HEAD ~ 1 é uma abreviação para commit antes de head. Como alternativa, você pode consultar o SHA-1 do hash se desejar redefinir para. A opção --soft apagará o commit, mas deixará todos os seus arquivos alterados "Mudanças a serem submetidas", como o git status colocaria.
Se você quiser se livrar de quaisquer mudanças nos arquivos rastreados na árvore de trabalho desde o commit antes do head, use "--hard" ao invés.
OU
Se você já empurrou e alguém puxou, o que geralmente é o meu caso, você não pode usar o git reset. No entanto, você pode fazer uma reversão do git,
git revert HEAD
Isso criará um novo commit que reverte tudo introduzido pelo commit acidental.
|
No SourceTree (GUI para GitHub), você pode clicar com o botão direito do mouse no commit e fazer um 'Reverse Commit'. Isso deve desfazer suas alterações.
No terminal:
Você pode usar alternativamente:
git revert
Ou:
git reset --soft HEAD ^ # Use --soft se quiser manter suas alterações.
git reset --hard HEAD ^ # Use --hard se você não se importa em manter suas alterações.
|
Um único comando:
git reset --soft 'HEAD ^'
Funciona muito bem para desfazer o último commit local!
|
Basta redefini-lo executando o comando abaixo usando git:
git reset --soft HEAD ~ 1
Explique: o que git reset faz, é basicamente redefinido para qualquer commit que você gostaria de voltar, então se você combiná-lo com --soft key, ele voltará, mas manterá as alterações em seu (s) arquivo (s), então você volta ao estágio em que o arquivo acabou de ser adicionado, HEAD é o chefe do branch e se você combinar com ~ 1 (neste caso você também usa HEAD ^), ele retornará apenas um commit que você deseja. ..
Eu crio as etapas da imagem abaixo em mais detalhes para você, incluindo todas as etapas que podem acontecer em situações reais e comprometendo o código:
|
Como desfazer o último commit do Git?
Para restaurar tudo de volta à forma como estava antes do último commit, precisamos redefinir para o commit antes de HEAD.
Se você não quiser manter as alterações que fez:
git reset --hard HEAD ^
Se você deseja manter suas alterações:
git reset --soft HEAD ^
Agora verifique seu log do git. Isso mostrará que nosso último commit foi removido.
|
"Redefina a árvore de trabalho para o último commit"
git reset --hard HEAD ^
"Limpe arquivos desconhecidos da árvore de trabalho"
ficar limpo
consulte - Referência rápida do Git
NOTA: Este comando irá deletar seu commit anterior, então use com cuidado! git reset --hard é mais seguro.
|
Use reflog para encontrar um estado correto
git reflog
REFLOGAR ANTES DE REINICIAR
Selecione o reflog correto (f3cb6e2 no meu caso) e digite
git reset --hard f3cb6e2
Depois disso, o repo HEAD será redefinido para aquele HEADid
LOG APÓS RESET
Finalmente o reflog se parece com a imagem abaixo
REFLOG FINAL
|
Primeira corrida:
git reflog
Ele irá mostrar a você todas as ações possíveis que você executou em seu repositório, por exemplo, commit, merge, pull, etc.
Então faça:
git reset --hard ActionIdFromRefLog
|
Desfazer última confirmação:
git reset --soft HEAD ^ ou git reset --soft HEAD ~
Isso irá desfazer o último commit.
Aqui, --soft significa redefinir para o estágio.
HEAD ~ ou HEAD ^ significa mover para confirmar antes de HEAD.
Substitua o último commit pelo novo commit:
git commit --amend -m "mensagem"
Ele substituirá o último commit pelo novo commit.
|
Outra maneira:
Verifique o branch que você deseja reverter, então redefina sua cópia de trabalho local de volta para o commit que você deseja que seja o último no servidor remoto (tudo depois disso irá tchau). Para fazer isso, em SourceTree, cliquei com o botão direito do mouse em e selecionei "Redefinir NOME DE FILIAL para este commit".
Em seguida, navegue até o diretório local do seu repositório e execute este comando:
git -c diff.mnemonicprefix = false -c core.quotepath = false push -v -f --tags REPOSITORY_NAMEBRANCHNAME: BRANCHNAME
Isso apagará todos os commits após o atual em seu repositório local, mas apenas para aquele branch.
|
Digite git log e encontre o último código hash de confirmação e digite:
git reset 
|
No meu caso, cometi acidentalmente alguns arquivos que não queria. Então, fiz o seguinte e funcionou:
git reset --soft HEAD ^
git rm --cached [arquivos que você não precisa]
git add [arquivos que você precisa]
git commit -c ORIG_HEAD
Verifique os resultados com gitk ou git log --stat
|
Simples, execute isto em sua linha de comando:
git reset --soft HEAD ~
|
Existem dois cenários principais
Você ainda não enviou o commit
Se o problema foram arquivos extras que você confirmou (e você não os quer no repositório), você pode removê-los usando git rm e, em seguida, confirmar com --amend
git rm 
Você também pode remover diretórios inteiros com -r, ou até mesmo combinar com outros comandos Bash
git rm -r 
git rm $ (find -name '* .class')
Depois de remover os arquivos, você pode confirmar, com a opção --amend
git commit --amend -C HEAD # a opção -C é usar a mesma mensagem de confirmação
Isso irá reescrever seu commit local recente removendo os arquivos extras, portanto, esses arquivos nunca serão enviados por push e também serão removidos de seu repositório .git local pelo GC.
Você já enviou o commit
Você pode aplicar a mesma solução do outro cenário e então fazer git push com a opção -f, mas não é recomendado, pois sobrescreve o histórico remoto com uma mudança divergente (pode bagunçar seu repositório).
Em vez disso, você tem que fazer o commit sem --amend (lembre-se disso sobre -amend`: Essa opção reescreve o histórico no último commit).
|
Para um commit local
git reset --soft HEAD ~ 1
ou se você não se lembra exatamente em qual commit está, você pode usar
git rm --cached 
Para um envio por push
A maneira adequada de remover arquivos do histórico do repositório é usando git filter-branch. Isso é,
git filter-branch --index-filter 'git rm --cached ' HEAD
Mas recomendo que você use este comando com cuidado. Leia mais em git-filter-branch (1) Página de manual.
|
Para redefinir para a revisão anterior, excluindo permanentemente todas as alterações não confirmadas:
git reset --hard HEAD ~ 1
|
O QUE USAR, reset --soft ou reset --hard?
Estou apenas adicionando dois centavos para a resposta de @Kyralessa:
Se você não tiver certeza do que usar, vá para --soft (usei esta convenção para lembrar --soft para seguro).
Por quê ?
Se você escolher --hard por engano, você PERDERÁ suas alterações como não era antes.
Se você escolher --soft por engano, você pode obter os mesmos resultados de --hard aplicando comandos adicionais
git reset HEAD file.html
git checkout - file.html
Exemplo completo
echo "algumas mudanças ..."> arquivo.html
git add file.html
git commit -m "commit errado"
# Eu preciso reiniciar
git reset --hard HEAD ~ 1 (cancelar alterações)
# OU
git reset --soft HEAD ~ 1 # Voltar ao teste
git reset HEAD file.html # voltar ao diretório de trabalho
git checkout - file.html # cancel changes
Os créditos vão para @Kyralessa.
|
1
2
3
Próximo
Questão altamente ativa. Ganhe 10 reputação para responder a esta pergunta. O requisito de reputação ajuda a proteger essa pergunta contra spam e atividades sem resposta.
Não é a resposta que você está procurando? Navegue por outras questões com a tag git version-control git-commit undo ou faça sua própria pergunta.